﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Tools.TraceVisualiser.Components
{
    /// <summary>
    /// Knihovana ikonek
    /// </summary>
    public static class IconLibrary
    {
        #region Obrázek Small_minus
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru small_minus.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Small_minus_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Small_minus, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\pic\small_minus.png
        /// </remarks>
        public static System.Drawing.Image Small_minus_Direct
        {
            get
            {
                if (_Small_minus != null) return _Small_minus;
                _Small_minus = Small_minus;
                return _Small_minus;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru small_minus.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Small_minus_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Small_minus_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\pic\small_minus.png
        /// </remarks>
        public static System.Drawing.Image Small_minus
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(420);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAJCAIAAABv85FHAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAOwgAADsIBFShKgAAAAKJJREFUGFdj3HDo8olrjxgwgIWWHEPFjK3/sQGgOEjuz5/ff/9CEZD958+v798+Q+W+f/8KRl+A6Nu3Lx8/");
                sb.Append("vH768BZU7uvXj2jW3b99CSr36dO7Dx/evH37/M3rZ69ePn784Obta2egck8e3rxz4/yNyyevXzp+7eKxS2cOnD+xGyp36cz+Y/vWHdqx4uCO5UB0YPuyw7tWgeSA/gNS");
                sb.Append("mAgoDgATQqT7EP+oXAAAAABJRU5ErkJggg==");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Small_minus_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Small_minus_Reset()
        {
            _Small_minus = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Small_minus_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Small_minus = null;
        #endregion
        #region Obrázek Small_plus
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru small_plus.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Small_plus_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Small_plus, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\pic\small_plus.png
        /// </remarks>
        public static System.Drawing.Image Small_plus_Direct
        {
            get
            {
                if (_Small_plus != null) return _Small_plus;
                _Small_plus = Small_plus;
                return _Small_plus;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru small_plus.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Small_plus_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Small_plus_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\pic\small_plus.png
        /// </remarks>
        public static System.Drawing.Image Small_plus
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(416);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAJCAIAAABv85FHAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAOwgAADsIBFShKgAAAAKFJREFUGFdj3HDo8olrjxgwgIWWHEPFjK3/sQGgOEjuz5/ff/+CEFAzkP3nz6/v3z5D5b5//wpGX4By3759");
                sb.Append("+fjh9dOHt6ByX79+RLPu/u1LULlPn959+PDm7dvnQBWvXj5+/ODm7WtnoHJPHt68c+P8jcsngXLXLh67dObA+RO7oXKXzuw/tm/doR0rDu5YDkQHti87vGsVSA7oPyCF");
                sb.Append("iYDiAIWxmffzwx+EAAAAAElFTkSuQmCC");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Small_plus_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Small_plus_Reset()
        {
            _Small_plus = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Small_plus_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Small_plus = null;
        #endregion
        #region Obrázek Note_16
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru note_16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Note_16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Note_16, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\note_16.png
        /// </remarks>
        public static System.Drawing.Image Note_16_Direct
        {
            get
            {
                if (_Note_16 != null) return _Note_16;
                _Note_16 = Note_16;
                return _Note_16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru note_16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Note_16_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Note_16_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\note_16.png
        /// </remarks>
        public static System.Drawing.Image Note_16
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1080);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAALEQAACxEBf2RfkQAAApJJREFUOE+tk3tIU1Ecx88KocyosZQay3xkigVlpRVa9hZ0ma1SSTMrH1kW9vhj+WrTMEtaSmVWurCQmuIj");
                sb.Append("H0RWlE4iLSqvqNXQJkm2LbXZNp93344gmCKB0IEPPzjc7+d87+UeQv7nSvEkJNmDcOJWkBmj3lnTkasbYsmnV5F8da0w9euzDQpVlZustcT1bNMjx+D3+QLv+hxr19rM");
                sb.Append("eYteygSzAUuiOMWfqB8yZRGNShwxZJRh2HAFAz0pMP1IQF/Habb3c7RRxxzUdr72VX0ocM5TiAVzSpOXTBSY2Wyia4+PYUeyAdym3Bkjh84blEz0aaRQyt0YhdiGV5w0");
                sb.Append("pSCBCm6NCUZF1ykyymXALIGxMwpvC1YzJYk2vDKJ3aQGQ1eJru1cDDuQDoxk0NA1yuhMo0gA42H0q0VoLFrLlEsW8ipTJwu0QUT3URjDdu0BtHuBvkgqiqfhRKA/Cujx");
                sb.Append("RX9HABoL3ZlKKZ9XddFhYgP0hBBdk/9xVhcMdO+niIBeOvUUGkb3VpjUfmh44MFUSAS0geO44N4xAaHvSX5+OSA1G+jJxiPA71DgVwAN+lC2UTbD0OYDZa478/iCLa/i");
                sb.Append("b8Gbh1tIrdyLq++KVmIkDmBjgeGjwGAIYKINjFRk8Ie+Yx+e33RnypLseOXSpeMN6vI3khq5p1VztTBDVRcw+L01GHpNGAZN4TCztA0iKFHQtIejImMNU3TefsHTNOeJ");
                sb.Append("30B+xoHcPWnLvS9eJipNX3npRa7nk/rSHW3NNbtN6qZAaL+FoqUuEIUpq1qCNnGdaHrmlH/62C7H28XSKjnM3ikv0c2vJMsroTp/Z7FSIXyXK14e78K34NIwZzpXhbPO");
                sb.Append("Ze7sE6LF1rvWz7c4tJ03ney/n/0DMRWSLsApR1wAAAAASUVORK5CYII=");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Note_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Note_16_Reset()
        {
            _Note_16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Note_16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Note_16 = null;
        #endregion
        #region Obrázek Contract_16
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru contract_16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Contract_16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Contract_16, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\contract_16.png
        /// </remarks>
        public static System.Drawing.Image Contract_16_Direct
        {
            get
            {
                if (_Contract_16 != null) return _Contract_16;
                _Contract_16 = Contract_16;
                return _Contract_16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru contract_16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Contract_16_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Contract_16_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\contract_16.png
        /// </remarks>
        public static System.Drawing.Image Contract_16
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1196);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAALEQAACxEBf2RfkQAAAupJREFUOE+F02tI01EUAPDr46+hUrjQLJRqPkq3KRgqCYVID6GgDwbqsjSXYaKslDArKbMHDp1mPjIzwzVX");
                sb.Append("6tT5d8tN85EuteEc6trcps7VbGpvEy2F0zY/9OFvdOFy4Z57f+ceDtcGbTB6i48iV7Rgo3cK3/ZrFRxGG8sMe0LJKD5/aqPj63sDpUFopccLabjewfrmsHMjrcyzQn71");
                sb.Append("IJ/D7uyoTvCSCp7ZoWBAtytMGyMDZTTUmo7s9c0hDSrJRegVVa+14TjwuSW/pbXHR9T1BxtlnOgIY0cMenEzmIj0l1BRfQzCjJ2xuGFqDAaHZCCRSIDH40HdUzaounJB");
                sb.Append("WhFWF+5KtuVcoRGB7iIqqo1GmEESh3+YHgOVSg0ajQbUajVodVNgnOiGLnZQS1Kgi/2TzAAi0FFARY9PIEzfTsenNHIYHpaDTCYzQypY/LkEpsk+ELMCBYk0Z/tKpj8R");
                sb.Append("eMmiovJjCJsU0XGjXmnOqgOdeU5PT8PS0jLMal+D8A6tlRHkjJWn7SUC+F0qKj6CMG3bKXx25h1MmJ9vyW6ZC58+w+SoGFpyKfj5fc5YSYofEWjOoyBz+7ExPh0fV7wB");
                sb.Append("hUJhrd/yihnDexgfEkBjToAwJdQFYyf7EgHeNSq6HoIw8YNEXKceNV+cBKVSaYWUShWM9PPheba/KHW/iwOL4UMEarMoKM0HYaL7ifji1zkwzc2BVCq1IvIRBbztaoCq");
                sb.Append("NN/2jMgtDvcSvIlAzWUKojsjTCbIx9dWV8wt1IJQKLSWYJqbh8FXDVCStKs9K4rkmBdPJgKPMinoEg3ZtpUzuINtpaCSd8NHowG+ff8B8wtfQNJUCaUMLzEz0s3xRtxu");
                sb.Append("IuDltgkpCnei/DPu4Q9TPes5WRRdEytqWVzDhG5BBXALTkNVum8PmWS39d8/aj1i4+fp5MQ47Op3i046WXbBvZCT7d8nKjpkqrl6oNIcJ1nO/A+xxj1Imy0LFhG8fUdO");
                sb.Append("clhoRmyAx3qKv/f/AE4thWdRu0vzAAAAAElFTkSuQmCC");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Contract_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Contract_16_Reset()
        {
            _Contract_16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Contract_16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Contract_16 = null;
        #endregion
        #region Obrázek Invoice_16
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru invoice_16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Invoice_16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Invoice_16, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\invoice_16.png
        /// </remarks>
        public static System.Drawing.Image Invoice_16_Direct
        {
            get
            {
                if (_Invoice_16 != null) return _Invoice_16;
                _Invoice_16 = Invoice_16;
                return _Invoice_16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru invoice_16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Invoice_16_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Invoice_16_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\invoice_16.png
        /// </remarks>
        public static System.Drawing.Image Invoice_16
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(980);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAALEQAACxEBf2RfkQAAAkZJREFUOE+tk01sElEQx19NNcY0qRej3jwYgR5NjMbE9KimVRsPpgcvHjyZ1HgwGhMLsV5A29qCxfJVuhSh");
                sb.Append("gHwsyyKsu1AKK7t8LEXaYoO1aptCjNWkMenJcZceBdKDk0wmmffmN/OfvIfQ/zSNi0bP3EzHazp7cSbKnRvzMCfu6Vydsut32+t92g62bmelMsgazchxNrdBcsI2Iyx/");
                sb.Append("iQtlPpYveyP80qiJmL8MAKhXaWgMmqazyM7kFBqXt/bIbgctzcAIGQYjE4cgnwc8VcCkOXoGjY0BmAiYinAKiivU6GwBAiwHGB0HfYQCeyIFeFJoDZAkTBLz8uBcuvq+");
                sb.Append("9BGKla+w9HkDPogxs7gCIXahNWCK4pHlbVo+ijmqKt0EaCxW0Ls84IzSQMylxJiqA3qVTSTsLpGXmd8Eq2qDCZ681MPguA4ei642WmDCgbcGGEJJ9ApPyGYJatPpD4Ez");
                sb.Append("QILNi4N+xgljFhu8mHbXAVeUpsZLNJIsMoRSp3zRxKaHiIIrEIZZEYK5/WB1B+C50b4LUDUBYHQO2eicgi2u1BKZBXiX5IES3ROmweQLgnoSqwOuqsz/TnDpwTjKr1YR");
                sb.Append("wZf71r5v76xv/YbSp3UIRGJAs1mIcwUYNjuaA44pTqMfW7/QiM3Xj8fTOa5U+VmsfPvDCosglNeAFZbhqdYsrX+f9BobWlvHcSnffvJM99GbAw8vDGnN901uwu8iY6s2");
                sb.Append("L7nTf3tgSDw/LMnY8x880Hnk0PmeG7K+W3eudZ3t7hIL9++5eC8X/wJ/llN/cIWKCwAAAABJRU5ErkJggg==");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Invoice_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Invoice_16_Reset()
        {
            _Invoice_16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Invoice_16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Invoice_16 = null;
        #endregion
        #region Obrázek Mallet_16
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru mallet_16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Mallet_16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Mallet_16, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\mallet_16.png
        /// </remarks>
        public static System.Drawing.Image Mallet_16_Direct
        {
            get
            {
                if (_Mallet_16 != null) return _Mallet_16;
                _Mallet_16 = Mallet_16;
                return _Mallet_16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru mallet_16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Mallet_16_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Mallet_16_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\mallet_16.png
        /// </remarks>
        public static System.Drawing.Image Mallet_16
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1000);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAAPiAAAD4gBFsilhgAAAlZJREFUOE9jZMACNFTVGP78+cPCxc0dys3LYyksJDRFWETk1onDRxhu3ruLTQtCTFFWjsHM3JxBT1cvxNDQ");
                sb.Append("8K2Tk9N/fz+/E2HOdgFBukrsASY6+A3Q0tBg0FTX4DcwMDhsYWHx39XV9b+dnd3/QFenLyGeriXG1nZszo6OuA3R1tQCGqAubm1lfcbNze2/paUlGFtbW/93dnb+5uHu");
                sb.Append("3m9vZ8fv6OCA3RBtDU2whKeHp2GAj892F6AXzMzM/oNcY2Vl9d/W1va7laWlq421NW5X9EUFM0yKCGWblBY1I9vP9b+ro8MXoAH/zM3N/wPxLQN9fRVDAwPsBpS6OjEc");
                sb.Append("n93IMCMzPr45zPN7gqX+OX9bax9HR6dlFubmF4CaQ+MLsxk01dQxDXCSkWeYm5fMMD0j3rA3Puhuqp3xhxgTXd8AM10GWytrLktzcxEFWTlGVSVl7LZPTIximJgUIzQl");
                sb.Append("LXJzgZvV/2gTncZEHT3mqX4e+KMOJNsU5MeQbe3ENCMztr46wPl/qJHmYSUhQROglBIQiwExNxAzYzUpy8KSYUV1Dsjf3u1Rvu8TrPTvWyjI+AIV6wGxIRBrAzHI3RJA");
                sb.Append("zAvETCgGATUyTE2LU5qQFHou09Hse5SJThJQgQAQg5KdBlSjJJAWxzCgJyaMoScmgmtaevT8Ei/b/8GGmksEODhAcWQExDJAzAa1jRHDZpDE//8XgU6Py2oMdf8VbKR5");
                sb.Append("U1aALwxqK8jPhEGlnzdPQ4jn5gRrgzdm8tKpQB2CQAyyjVjAxuirrarto6PmpCshxm4kBQon4gEAJPahbmJmPJEAAAAASUVORK5CYII=");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Mallet_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Mallet_16_Reset()
        {
            _Mallet_16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Mallet_16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Mallet_16 = null;
        #endregion
        #region Obrázek Window_16
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru window_16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Window_16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Window_16, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\window_16.png
        /// </remarks>
        public static System.Drawing.Image Window_16_Direct
        {
            get
            {
                if (_Window_16 != null) return _Window_16;
                _Window_16 = Window_16;
                return _Window_16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru window_16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Window_16_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Window_16_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\ImageStretch\ImageStretch\Images\window_16.png
        /// </remarks>
        public static System.Drawing.Image Window_16
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1208);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAALEQAACxEBf2RfkQAAAvNJREFUOE+lkl1MkmEUx5+s3Nisi25qq0vrurXuumnVXBfVcnXTurAuMjcvbDWX5lypqZmCghqlApn4VfrK");
                sb.Append("hx/Ih4oKoogiGKiICAgKqIkffAhyet637KLZvOhs5+bsnN/z/5/zIPS/0SYfQoRs6HwdISko5rRmv2JykzOKqy+m5padvvskM57kn0m89O9nNmKAxk2WQpvHB0abE2Ra");
                sb.Append("Q6RFOrRW095jon9p785n8yuyymufZhRVXkvNLU1MeZF38mryo7jbjzN+QcV6M1Jo9eVS7RTIJ6eh3zgD6jkbjFkdMDJrg/4pM7T1j8Y4InmA/a1rqYJPjOaweFXpeYyz");
                sb.Append("aW/oCOXwCCQcGCkf+z4HagPZrAJelwK4OBtkg0CotMCWjUOJWAssiQ54fRNQ36OETHrNs+dMHkKl7VIkVmrK7cteCO7uwvrWNtiWPTAxZ4WBSSN0qsaALx0CtqgP6ARO");
                sb.Append("gRI4nX2Q/4lfWN2pRIjR0YdEGLCIh4LhMGwFguDfCYBvww+LHi/MOl1gtjvBuGAH3ew8qAwmIAZGoKiuuYgj1yBUhSkkgFQQwgp2QqE/EFLN8toPsK14wOpeBosL55Ib");
                sb.Append("+ieM8P7z13fN6imEPkrUSIR34MRXiESjFCQQCsN2MASbgQD4t3dg1b8J7tV1cHpXweH1gQovmsEnSgR6C0K1Mg0FcPvWIBaLUZDdSIQCkZb2FW38BpHWtDNWYLUIS+Xz");
                sb.Append("Kwg1ydWoQzGcbVpwUMP7QcKie3tULYyBwTC2h1WROzJY7fChrZM+6gsg1ECIUSWnPrFJ3MuXa3Q2g2Uh5PatUzZIyN/AaHQPZhxuqBVIGKYwIHQ07gj1oW4kJdFevi64");
                sb.Append("wOTU328Udpf1Do8O6swWj33FGyWvEsGD+zHv9kCdoId14P8+kZBA1uNu3rpzKreo5HJNY2uqUKHkjkxN6y1Olx8vNGZ2uKCM28DGfVTzoUGj0eLvPXh47i2DeZ1PiLIa");
                sb.Append("hV2slLT0K3jw2KHDBzTE4dpxnJT3n4/JVMQOeoaEAAAAAElFTkSuQmCC");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Window_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Window_16_Reset()
        {
            _Window_16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Window_16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Window_16 = null;
        #endregion
        #region Obrázek Zoom_48
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru zoom_48.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Zoom_48_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Zoom_48, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_Selected\zoom_48.png
        /// </remarks>
        public static System.Drawing.Image Zoom_48_Direct
        {
            get
            {
                if (_Zoom_48 != null) return _Zoom_48;
                _Zoom_48 = Zoom_48;
                return _Zoom_48;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru zoom_48.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Zoom_48_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Zoom_48_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_Selected\zoom_48.png
        /// </remarks>
        public static System.Drawing.Image Zoom_48
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(4776);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAALEQAACxEBf2RfkQAADWdJREFUaEPtmWlUm9eZx183qeNMkknSxO00zXIyTTuZnEySJp1JmtRN2tqO44ld23Fc2zHGC17AbAabxYDZ");
                sb.Append("xCJAIAESEtoQoH1HgBBCIBBg9kXs+2bwgm0wixds+M/70nhOvkxPPmCTOafvOf8jfdC59/97nuc+995XBPGP5x8RWJ0IbHz3SeKXzxBEpMenP2ZHHniGH3/seQH92PP8");
                sb.Append("WNenUs9+/lihOZLYs251vP2fs2ZEuxARpzY9Lkr2eUMvidtXpM1glOSJjcXGrOoCDb8pT8lrNMg5dk12slwhiAmTZYRulrPP/LQg7a9rdOnHVo+GE+NG0M/uWCvnhn1W");
                sb.Append("ahKLa8pNw6XFeffk0myw09NAp9NBT0gAi8WCQMBHbq4EcmkWpFmceQmP3pzNiYhQ8EJ/Vak6u8YkDn50IIxzXxOFqnRCyPB53WrIzGiusU3pNEp4+/hi1+49cDnsBr+g");
                sb.Append("ENASk8HkCsDLlkOiNkBmNEOdb4HOZIZKrYYgM32Jy4zqy+aEnzJIop5WiyIfPgQV9ZoyHZHLDv6opkxbV+0ohZ//GexzOYSQiGjkKNSw2h1w1Dagsr4J5XVNKK1thq3O");
                sb.Append("CVtTF0rbBmHvHENFxwjs9a2QyuRIio+4m8kKExgksetVQtrDgxAn+xJqYTSRkx742waHqaPEaoH3aX8IJDlobutA78AQ+odH0Tc8ho7+ITS098De4ESBowEa2wVILVXI");
                sb.Append("Ka6BwuFEvnMM9sFpVHRfhFJvQtT54CVOUkhOgTTpOY04/uFAkMYJXvzJn1ZZFbbqqgrQ6Emob2nD9ekZTM3M4frNOVy6NoXB8cto6x9BdVsPimud0Jc3Qkoa5+c7wNKV");
                sb.Append("ga4sQbK+EtlVvTC2X0VRxyVkKXUIPON9X8A6f37xYvEalShuZSFkGSFEvaOAMOYm+XS1NSwyuUK09Q1h/u493L63iJnbC5gkAcau3kDP6GU09pAl0tqL/Jp2KO3NEBfX");
                sb.Append("g51/AQzSOF1XiURjDVItrRA4+iFrmoChZRS0BAbOnfG4qJUkvacQrHAWyJonUiMO/qTOrr9gsdmRY3Zg+tYCbt9fwvy9peXvl6fnMHTlBtqHL+FC1wgszX3QVncgu6wV");
                sb.Append("XEsjmPn1SMyrR0JeAxILWsC0doJt70dm9QgkjZcgMlfjmNthcJJCaX/600ZCLkxYuSyQvZus/aCP2psc09lGK6xto5gmoz63sIRZUtfnFzA+NYfeSzfQNHgZdnKRmhr7");
                sb.Append("Ia/sgsDWhjQy2smFLUgsbAW90Am6uR0Maw+YZf1IqxhGRvUYxDUjOOHjj7BAD3tLhfIppThp5QC04lhCK4rZ295ad19qa4C16zKuzt3FzN1FTN9dIr8vYOT6HDrGb6Cm");
                sb.Append("/zKKSUBt/QCyHN3g2DrBsnaAYelAQlEH4sydiCvqQnxxLxJK+pFUNoQU+zDSq8bgevo8vN1du8oKRP+izGKsHIBOkkBoxDFH250NKGgeQl7bBPqv38JNEuDGnSVcml1A");
                sb.Append("/+QcmsduoLz3MkytY5DVDkJQ0Qd2GRlpWw8Srd2Is3SDVtSNKHMPoop6EV7Yg3N5XQgydiJA144/f+MDzxMu/bZ88ctKScrKAaiFMYSSH3m0ub4K5Z0XYWi7BMfQFC7P");
                sb.Append("31/OwOStexgggZouTqO8bxIF7ROQ1Y+CXzUIdvkAUkr7kWDtQ4ylF5Gk6VBTF86Qhr1VrfAi5atpw8EMO/7ri/0ICfDstxpFr6izmSsHoBLQCEVm5OGaShvqOgdR2HkF");
                sb.Append("5p5rqB+fxdVbVBYWMT5zF6PTt3GR1DipmuEp8C+Mgu0YJktkCPElA4g09y5HmzLuLm+GBylPZSuOZ9djc4AYGzZ9CTE/tU8vS39ZK2WvHICcF0HIuOf/4igtXGhsIXfV");
                sb.Append("znEU992AbfAmGibmSfMLmJi9i8EbtzFx8w5Gpm6j6+o81M4rSK8cXa5zqmQCDH8z76H4m3kK4mhWHbbH5uP9HR7w8vKCtVDnFLOj1+tknJUDkJJdKDs14C2bWT3R5nTC");
                sb.Append("XkceD/quLQPYh2dROTqL2rFZNE/M4RrZkShdIYGKuq8tm4+x9CG8oBsheZ0INLTDT+OEu6wJB3iV+O8YEz45loA/btkGs7kAFpPSGBd64gmlJHXlAGTcMCI98sA6kzJD");
                sb.Append("29nuRGurE0WV9SjpvYbSwRlUjczgAglQNTqD8qGbsPZNIa9jEvLmSxDXXQSvagQs+yDZefoQmtcBj5x6fM204vNIA35/MgUfb9wOhUKBpoaaRa0s072ltpRw2btjBQF4");
                sb.Append("4YQ6i07I+VFfVtkLZ8bHx9HmbIOx2I58sisV9EzB2HENpo6r5PogFzEpQ9sVKEmArNoxpNkHQCvohJ+sAa4cO3YmmLElXIPfHQxdrvtsiQSDgwMoKTLUizhxL5n1WStn");
                sb.Append("/sFIuRwyC9FH1xpkaSntrfVLU1NTGB4izRcVI9dkQ255ByQXRsAjFy2L7O/0wm5EGtoQpGyCd3YN3DIrcIBVgl2xOmw8lYgPNu/G519sRVpqKlpaW1Bbbb+ukLB3AXeI");
                sb.Append("k24uKw9AjdhdrSCEyQHrCzUCWX932+KdO3dwa36eLKlWqHUGpItloAvViBbnI0xswdlMMzzTjDgaL8VfA5nY7OKLD/6wGb/f8AcEBQaAzWZDJpOixJI/pZHxvXZu/fRx");
                sb.Append("AA/H/INRgUkiM+nMi/kqHrOnvWF2bnYGk5OT6OnuQVVlJfR6PYRCIRIZKQgNj4SP3xkcPHQEX2zdivd/8x7+7c03EXguFNXV1WTZDKHCbl2UZ7G5acm0f09nc9dlZTKI");
                sb.Append("DUcKHirEGmr0834H1ilEiV87SgyVzubau40NdSgpKYFKpUJGBhc0Gg2+vr5wdXXFtm3bsGHDBrzzzn/g/Q8/xp5j3uAKRKh22DFxcXhpsK9jusQoGFUK42Rahfg9ZcZZ");
                sb.Append("QquWPXQICmRN2JnDP8sVJO43qIQqozZ3QCEVz3M5qUsx0ZHwP+2D425HcPDAfhzYv2fxsOv+qdCg05c8/AOXTnh5o1gtQp1Vi8X79zA53gOjMADkjt+mVWZ/oJNnEuT9");
                sb.Append("+qFD/Iic4TFKn33ym6cjgz1+zUmJ2Mpnx3tmpsfTOMyY5DRGFIOVGBGeQj9/PCzIe0ugn/tWfgbDGX5iOziBLrCpeHBWF2Nx8T4GOxxQsz2gEsY5yHv26zplzkMFeDA4");
                sb.Append("lQkK5HFSP/5Wa8lP6g3QP32rJ7/9fGHdk0+/XqRhmxqNsaC5fgJBxHEU5TLR21yB2enLaLJLoUh1B3kWUuv1hhf0GvkjgaAmeQDyICsU0HdFQT3785de+aVCQLMNVKah");
                sb.Append("RhWGaBJCHH0SeQIaeprLMDHUinJdIuRpnotaKZdpzC95Uq/TPDKIvzcRVWrkezviVS4zXKznemL0AhuWTG/EHNkAUdRR6Hlh6Ko3o7vRjEJJEBQc/9s6pdjfYG19TKfT");
                sb.Append("rToElZmnSP38rJ/nPikn+JqJdwJDlSyoEw+BfuKP4Ie7QM8NRotDiXqrEDqOB5S8kBt6jWyvLPhNQm8wrSoEVWJPkFq/9ol1b6QkRMTI0v3uFAlPobOYDknkHjC8NiEz");
                sb.Append("bC8M3ABcKOSSCzwWStZRqES0EYNB96lOJSK0+vxVhfjfLLz66mtvc1NjhfI0r8VisRfqtGHgh+wAy38LeGG7yUz4oURJg5HvC1nKYWgkjGZDXsFbRoOWyJAUrSoEtbD/");
                sb.Append("mdTLH3740W/FGfH5ctZJlGR5o1RyGtxz28EO/JIsp6+gYZ+CgecNRcpBEuIYdNKMIlOh7aU80+pmgSolqt0+R+qVXbt2fZbDi6+VM91gEXkij3McvNDtyxJF7YY82RWy");
                sb.Append("pP3IjtsNKdMdeqVIVGitfia/wLKqWXiwHl4gXbx28uTJHTJ+bJ885RDyyYWtZLiQ+8NOEuArssWSitsPBfs0pCxPSFj+99RycXR5bc9as8W26hDUZree1OshIcFH5ZmR");
                sb.Append("V+TJLtCkHkIOfS9E0bvAjdpL1j8dOZI0pLMTkBznC2aU+5wiV+TKCHMjDMa8VYWgFjW1W/+MWPOjNxLoscHkfwazVMlIE/eBE7oNAoYvsiQZqGlshLm0DIkcDoL8vgEr");
                sb.Append("xqe5yGp/yWg0rioANTm1wS3vDz95cf2bnLRkpoJzdiGHvgcpQV8iKcYH2Ro1Gsk7R31TE0RyBUJoYYg8u29Bp1Z8pVU/uqPG34sU1ZmoXfoXb739zrsiHlMuS/Vcop/e");
                sb.Append("hPCwU2AKhDCai5BvsYCXkwv/sHM4570bGmWuh1b1aA583yfNVGd6lupMGzdt+V2OgFmaHLwTpz12ICguHsm8TLBIkIjkFBw+eQhRgQdvk2ekrfmm1S+hB3BUZ6IOfM+T");
                sb.Append("etX10JHP+alRzrNun+Hg0b04ERgMj5AwuHp7wf3YX5DJiqrQ5VledDgqv09wHtlvHrTXF6n26ufn/3V64rmuAPetOHJ4Gw657Ybvqd1ISwgaUChkm6j784ED3zwyc993");
                sb.Append("IqozUe11GeLIEbeNqYwYHivuTAOpJgEnUczP5H/8i9d+TS3+H+zzAOI5qsU+/cyzL3/25y2/2rl7/7++/e5/UscQyvzy3fyH/FAGqe5EZYNqs9R+QZ1m/1+Y/25gl18e");
                sb.Append("fEc/5KCvjLf/AVTNF5DjTPgTAAAAAElFTkSuQmCC");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Zoom_48_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Zoom_48_Reset()
        {
            _Zoom_48 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Zoom_48_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Zoom_48 = null;
        #endregion
        #region Obrázek Binoculars_48
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru binoculars_48.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Binoculars_48_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Binoculars_48, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_Selected\binoculars_48.png
        /// </remarks>
        public static System.Drawing.Image Binoculars_48_Direct
        {
            get
            {
                if (_Binoculars_48 != null) return _Binoculars_48;
                _Binoculars_48 = Binoculars_48;
                return _Binoculars_48;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru binoculars_48.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Binoculars_48_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Binoculars_48_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_Selected\binoculars_48.png
        /// </remarks>
        public static System.Drawing.Image Binoculars_48
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(5232);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
                sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAALEQAACxEBf2RfkQAADrtJREFUaEPtWHdU1Ge6HkCjIBELGgt2BSJFQECQXpUylKHL0DsMZWBogxQpUgSp0kUFEYwggggoIAoKKnaT");
                sb.Append("mJNsYjbZcm/u9e6euzc3N1F57vtNzJ6wJtlsNhvzh5zznjnAb77vLc/7vM/743Be/bzKwKsMvMrAqwz8mjLw33/5ggNA+s7997b0D110JfO4NHFda/rmvfnXp+/PHRuf");
                sb.Append("dL04PlkxPjkdcWn82kp69tfh/syX4Fy9fpfzwUe/X9rZ1ZspSst45B8c+iQ+KeVpZl7hZ1V1zc0XRi5n9w+e/9O54TF0njn3rK659VJb+ynDyeu3V3z6h/+UvfP2hyz4");
                sb.Append("Xz6ge/ff5+AZpKam7xnUNh0dihWKnh4or8KZc0OoaWqBk5sHdnF5M8kZWU+zc/PRdOwEyg41IFGcjcKyqt8mpYofltfUd53uHdQh76V+0Qiu33zAuX33ofyFsauCorLK");
                sb.Append("T4TJqXirpw+3HryL4YkpHD5xCjnFZbB35sHUZjfcvX1gz3WGkYkZQiOiUHe4FcFRcdimZ4hwQcJUeVXdRhZAcU61VG5qJic2KOpfE8+N6bucI2eGOVembm09c264IyMn");
                sb.Append("78vMfXkYHb+Cew/flzjf2NqB/LIqJKRnISwmDtX1DWg42oqQ6FhYObhA18gU+juNYWHnBM2d5uB6+HzV0NwqOHW6L2rgwljT0OhE2tmBEdW9wiSpnxVaE5PTnJu3Hswb");
                sb.Append("GL685+SZgYfJGfsgTBGj//wI7rz9EKPkfD3BJO9ABeJS9iIwQoDcogNoPXkKRZU1CBIIsdPaDm9q62Orjj70TSzgExIBexfezPGTXY8IS18MjF5CZ+8AqhuPPGw+2u60");
                sb.Append("cY2S9M9SitO9Q5xzQ2NL6prbKvaXVf1PamYusvIK0d3bj95z51FLkDhQ04B9JeWITRbDKzAMFrsdwQ8MRnpOPmLob7auXlDV0oOuxS5wvf3g6R8EfnAoXl+4EEGhYYhN");
                sb.Append("EEKYKsa+4oPwp+BDBYkfllYcMqAA/rkgenoHOINDF2VbWjsOHjzU+CwrvxBOLjyoqKjAwcEBdQ1NEIlz4BcajYi4RIjSM5CQko4QyvguZzcYGJtih6kl1PSMoLHDGG5+");
                sb.Append("weBSgy9RXAae9x6J8+70mVd8AAKhSHIGC3bnbiek5RTUb9m4ccFPavLOkz2cw83HpPoGhjX7L4wd7uzp/+LYWz1oaX8LlfXN8A0IpuwpQElJCYLYePj4B8PC1h7qGtug");
                sb.Append("pqaO3Q6OKKmollRgu6Exlryx8pmyuuaMlZ0DFiooQEZGBmvXb0BhaRlKq+skTe22JwCu3nwERgrgT7/nlpRPOXKd11AAc340lBqbjnE++PfPOKd6+pXOnr+YOTA68UnP");
                sb.Append("0CiOd/eh7VQPDh/vQBldyKBiSpieLyuHJUuWgOfmDjMrW2xSVsVrr83DosWLYW5lQ80bB9NdDtiopvVEccWqr+QWyM+oaW5DdEISUrPziFazEJ2YAp5vIIxtHaGqu5P6");
                sb.Append("RA9elJDSqropc3NLxlDz/m4AR9u6OKfO9HM6unoXnu4b9O8fvnRrcOzqs9ODozSA+vEW4b21swuVdY2IFaWB68mHCZVZabMqm0JQoKzuNDLGps3KUFz2BtZQdjcpq0BD");
                sb.Append("Zzt2WNpig6oaTGx2PwuJFjypO9I209jWifzSyq97JiAUFg6u0DSygKaxFbab20JVQwu+wRGPRWl7eXT+/B+EUdPRTs6N6UlOZ3evdteZs31nBs7/3+DYBPpHx9EzOIze");
                sb.Append("wQs40dWDQ40tdGE6HN33wIiypUE0qErYlpV/XRLEQmrI9eS4LFVlo7IyTCytYbHLDj5BodhK0GK4zy0qQc/ABRSW1yAhLRO+IZGwcfaAtokV1Om8HTYOsHXzgYbuDugY");
                sb.Append("WyAsNqnbxtpG8XubefTiBOedB+9LdfeeczjTP/je6OVx3Lh9D9fuPMD49VsYGb+K7r5zaDjSijjKlj0dbkiXqBuaSy7Us7TDslVKkgBk5szBsuXLIS8vj6WKy575BoX8");
                sb.Append("OSQm7iur3fbYrKIKbb0dcPbwRnFFDZKIhsk5uPgEQJcyrmZoBl3L3bCkYNz8Q6FOAWzRMYCDJ//f4hNTjL6zDzq7+zjLVNQ5pdX17sKM7D96hsTAOSAasek56D47gPvv");
                sb.Append("vocLY+M4euIkElIzYEfsYGBlJ7lMg8qtb20PM0ce1m9RxdJly7F2w0ZJpreoqmKnsen4Hn6AP0kMkW9A0CNndy8EhIQjnAZanDAZeYUHUEAzIyI+BZZcN+hQEKZ0lhtR");
                sb.Append("sI2TKzaqa0Od7rB28XqakCIO/U4Y1be0cVraOtfGpu59W1PfEMrGPKSWtUGwrxa6dnzEp2Whf2gY4n0FdKg79FimDJjzlthh7QAL+pu1iwd0DAxhQDKBMYyLlw98A0Nu");
                sb.Append("mZiaO9KlW13dvfy0dHQfyxPMFsjJYcGCBRJbvXo1fPl+kkBCY4g6ed7gEgvxI2Jo0On9NUF2nvyZ+BSxkM6SfwFGJZW1nIq6Zq5XQMiXsvIKULf2w9T9D3Hp3sewFFRA");
                sb.Append("YzcfvhHxNFnFfy3zNhNrGNg4kvNU6sCwZ/7h0R/vCQy5T1LhdrRQdC02KbV9l72jE12mRrbe3csnW0FhkQRi37Y5BDdpGWno6esjKjaB6NMPfuS8pZ0jtuobwYB6zMzR");
                sb.Append("Dd4hUZ+Hx8Tz6bsKZDKz2IgGE6e8rsmT58N/Ks14WdcOreeu4eK9R/Av64ZdcgWsgpPgF50AS1YBgo8JsYUEp1RqYXrWXUdnV1dllTeNtiirGKxbv0FPTk5Oky5RJVtL");
                sb.Append("tphgE7Ji5aon3zhPvUEVCkYxKVdxdi5MzC1hZm4BF4KYlR0X2kbmMLTlSqrr7BsEQbJ4VENzmwZ9f+ELFWhq7eBUNRw2CI6M+dO8efOgsEYVCQfbcf7Ob5B+fAQhh7oR");
                sb.Append("XH4MQVlF8A6NgjX1AI8azCM4AkJx9n/40RilQ9XJlMnWkSmRrSJb9rzk8wKCw9QNjIzvSktLQ3WrGsprGzA2dRPD45Noo8FYcLCaJEU4bKjR9Q2NoG1oIkmQMz8I0aL0");
                sb.Append("PweFRQbQWavJ5F6g0vauXk5ecdliWj7GNhNnS0nPwU6PcNT1X0HdyDRSTl5AZs8Isrr6kZC7H/7R8RBl5yM5O/+rOFFaiYy0zDY6dPNzh9nIZ3zNhg6bnEzDMJOPEMSL");
                sb.Append("AkMjnrSePI3L12+T81dxorsX+8l5Eemq8DgRuO7e2Ka9Hes3boG1kxuiifFSs3K7FBWXvUlnLH1+5iwEcajkkm2opKImMCAk7Iv58+djwWJFuCfloHZ4EgdHJ1F6aRLV");
                sb.Append("UzdQSJI470A5altakVVQ3Ke0Zq3hc6gsf+70rKWE57mHs1JprUxhaaVdx+m+u+fHp8j5Wxi9MkUMN4jiylokZuQgJEYId8q2NUGGqdRFixZDnyR3VlHpZz5+gR7PKyr7");
                sb.Append("Qva/HYoPP3Dx/gMHjzm5uGLu3LmQX7IUzqRFivsGcOjaDdTfvInKjk60kTQmKfGOmaW1hGG+r7RZeUWcmITk+TWNLVEne87+4fylq5iYvoPLU9M4S/KbaSnqHwRTRZmE");
                sb.Append("sCT63G5G05eG4oKFi8DQQJtcq5zcAgbNxWSzm3d2HSS/SYdGCjbvLyk7u8fPf2Y5DSPW1EqkOM09vRCalYXGtuNsHrxPEjmQnme4X0/GGmvW4eKcfE5UQrJsffORvFOn");
                sb.Append("ez8fHLmI6zQY79PCc3X6NuH+NA2xHBJssXClIcYkhI6pNbYamEKLPtfRTNHervs7Rxcel85e+RyW3+Hyi3+a6+zuubmgpKyGdtjHjKMtLS3B5XKRX7Af1XUNt514Hl70");
                sb.Append("NcYITGCxzMxSiakZ2Rwv30AZ2nWFR9o7/reD5MfI5Ql88NHH+OiTT3GRlp6iikMk3lLBI843s3eGFkmIr523kbCPifWuGa6rW42srOwmOn/Rj8n+N6EwDL9GlLc8NErg");
                sb.Append("VHigrLaqtn78UH3j1dz9RQ20z9rT/xm3M+eXsGe/nQOqoKSfKLse4cLkx3aefjDzisGuwBT4C3NQd7QdF2n1ZDKC6R9bYppvnNcm+DD9v9udhmBw2PSOncYmdPYKsr+v");
                sb.Append("Qv+mEJIgGDSkpKRWLV6q+CYJME0paWnGBFvImDZnWZlLNqtpWzq6OEnpe5dHJaZe1zcxx9JN2xFf3IbuS/fgmnYYWi4C7IlJoXXxMAhiXw9GmupMQhjZOWMXCUTaxK5a");
                sb.Append("WNva0dmMkl/k/R8FpK8fYrhmnc+mH6MwxusMMoyLv3O5uPHubziJ6Zn6QdFx/6VIuuj1dVpIr+zEB79/jMT6IRhFlcKQL4J7TBqSMvfBnMuDtpkNjO1dYEvO+4YL/uLm");
                sb.Append("zWeahznPKvzjl5gfCIzxOAuGHcY+v/f9DYNPXHL6DlKfjxUWLYKs4jq4xJVg/P4jFHddgVvBCTiLq8ATlyE4PZc2rliYE3U6ePuDTw0dKUweXrV6NZviLFkMBb/suyKW");
                sb.Append("BC9+wNqEVPG9daRKpebMg6ZjKCq7xnD88n1ENp4l60FUXQfi6kiaUxW8giMRmZRGgzHvc09+QAQdwSb5T9uB/wF4/dCj85P3ZhdzaemXlpLCkrUq8M6sRvOFGyim6Z7e");
                sb.Append("NYycvlHsHxpDbssxiLJyUVRViwxSAitWrWZTnS0uPwt0fmo8Mi6ePhoiceZdLW0difrcoENv30qbUDMyhfIxMprIh27cRHnfWVTQetrY2v65f2hE9K8h+yxohlvZoMgY");
                sb.Append("Hr37/FRbRwdMxL1B+sZDJEZR/yDqb0yj/tYtVPf24nBrO3IKSzqJ7dhsYWTB2O2l/7BmX0hZ9UzLzH6H5+6OVStXYh7pLCXak41dXBCWsRe1R47QMlMyRhucMT3PFOyL");
                sb.Append("avMlhsIyudDG3tEodW/WkcycfX+MiY2dCQgIQHR0NErLyp7mFxVP0DtSW3qOzZbXn7PcS3R59tUMSqwZ5ek90GoKxEaQKNqblVdwLDuvoC0sJjZdZasaU7PMeTZrXmrj");
                sb.Append("/lDWGJzYjsCmKuN3tpiwTe2bpYdl/lfr/LcDY4EwWLHpzrDOPtnv/9yL25cEuF9+wr6kQF9d+yoD/6oM/D8AMJB7OtGpLgAAAABJRU5ErkJggg==");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Binoculars_48_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Binoculars_48_Reset()
        {
            _Binoculars_48 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Binoculars_48_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Binoculars_48 = null;
        #endregion
        #region Cursor Handle_Arrow
        /// <summary>
        /// Vrátí cursor, načtený ze souboru harrow.cur.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Handle_Arrow_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Handle_Arrow, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\Images\harrow.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Handle_Arrow_Direct
        {
            get
            {
                if (_Handle_Arrow != null) return _Handle_Arrow;
                _Handle_Arrow = Handle_Arrow;
                return _Handle_Arrow;
            }
        }
        /// <summary>
        /// Vrátí cursor, načtený ze souboru harrow.cur.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Handle_Arrow_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho objektu Cursor (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat cursor často a rychle, je možné využít property Handle_Arrow_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\Images\harrow.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Handle_Arrow
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1024);
                sb.Append("AAACAAEAICAAAAwAAQDoAgAAFgAAACgAAAAgAAAAQAAAAAEABAAAAAAAgAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDA");
                sb.Append("wAAAAP8AAP8AAAD//wD/AAAA/wD/AP//AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMREREQAAAAAAAAAAAAAAEzEREREAAAAAAAAAA");
                sb.Append("AAAABMxERERAAAAAAAAAAAAAAATMREREQAAAAAAAAAAAAAAEzEREREAAAAAAAAAAAAAAAEQAAAAAAAAAAAAAAAAAAAB////4AAAAAAAAAAAAAAAAf///+AAAAAAAAAAA");
                sb.Append("AAAAB/////+AAAAAAAAAAAAAAH//////gAAAAAAAAAAAAAf///////gAAAAAAAAAAAAH///////4AAAAAAAAAAAAf///////+AAAAAAAAAAAAH////////+AAAAAAAAA");
                sb.Append("AAf/////////gAAAAAAAAAAH/4j//////4AAAAAAAAAAf/gA//////+AAAAAAAAAAH+AB/////9/gAAAAAAAAAf4AAf/f/f4D4AAAAAAAAAHcAAH+A+A+A+AAAAAAAAA");
                sb.Append("AAAAB/gPgPgHcAAAAAAAAAAAAAf4D4D4AAAAAAAAAAAAAAAH+A+AdwAAAAAAAAAAAAAAB/gHcAAAAAAAAAAAAAAAAAf4AAAAAAAAAAAAAAAAAAAH+AAAAAAAAAAAAAAA");
                sb.Append("AAAAB/gAAAAAAAAAAAAAAAAAAAf4AAAAAAAAAAAAAAAAAAAAdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD////////////gA///4AP//+AD///gA///4AP///AH///w");
                sb.Append("B///8Af//+AD///AA///gAH//4AB//8AAf//AAD//gAA//4AAP/8AAD//CAA//hgAP/44AD//+AB///gB///4A///+B////h////4f///+H////h////8////////w==");
                return ConvertStringToCursor(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje cursor v paměti.
        /// Následující použití property Handle_Arrow_Direct si vytvoří novou, korektní - podle originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost cursoru v paměti nejistá.
        /// </summary>
        public static void Handle_Arrow_Reset()
        {
            _Handle_Arrow = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Handle_Arrow_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Windows.Forms.Cursor _Handle_Arrow = null;
        #endregion
        #region Cursor Handle_Move
        /// <summary>
        /// Vrátí cursor, načtený ze souboru hmove.cur.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Handle_Move_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Handle_Move, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\Images\hmove.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Handle_Move_Direct
        {
            get
            {
                if (_Handle_Move != null) return _Handle_Move;
                _Handle_Move = Handle_Move;
                return _Handle_Move;
            }
        }
        /// <summary>
        /// Vrátí cursor, načtený ze souboru hmove.cur.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Handle_Move_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho objektu Cursor (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat cursor často a rychle, je možné využít property Handle_Move_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\Images\hmove.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Handle_Move
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1024);
                sb.Append("AAACAAEAICAAABAADgDoAgAAFgAAACgAAAAgAAAAQAAAAAEABAAAAAAAgAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDA");
                sb.Append("wAAAAP8AAP8AAAD//wD/AAAA/wD/AP//AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMREREQAAAAAAAAAAAAAAEzEREREAAAAAAAAAA");
                sb.Append("AAAABMxERERAAAAAAAAAAAAAAATMREREQAAAAAAAAAAAAAAEzEREREAAAAAAAAAAAAAAAEQAAAAAAAAAAAAAAAAAAAB////4AAAAAAAAAAAAAAAAf///+AAAAAAAAAAA");
                sb.Append("AAAAB/////+AAAAAAAAAAAAAAH//////gAAAAAAAAAAAAAB///////gAAAAAAAAAAAAH///////4AAAAAAAAAAAAB///////+AAAAAAAAAAAAH////////+AAAAAAAAA");
                sb.Append("AAB/////////gAAAAAAAAAAAf////////4AAAAAAAAAAAH/3//////+AAAAAAAAAAAB/8P////9/gAAAAAAAAAAAB4D4f/f4D4AAAAAAAAAAAABw+A+A+A+AAAAAAAAA");
                sb.Append("AAAAB/gPgPgHcAAAAAAAAAAAAAf4D4D4AAAAAAAAAAAAAAAAdw+AdwAAAAAAAAAAAAAAAAAHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
                sb.Append("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD////////////gA///4AP//+AD///gA///4AP///AH///w");
                sb.Append("B///8Af//+AD///AA///wAH//4AB//+AAf//AAD//wAA//8AAP//AAD//wAA//+AAP//wAD//+AB///gB///8A////5//////////////////////////////////w==");
                return ConvertStringToCursor(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje cursor v paměti.
        /// Následující použití property Handle_Move_Direct si vytvoří novou, korektní - podle originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost cursoru v paměti nejistá.
        /// </summary>
        public static void Handle_Move_Reset()
        {
            _Handle_Move = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Handle_Move_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Windows.Forms.Cursor _Handle_Move = null;
        #endregion
        #region Cursor Arrow_NS
        /// <summary>
        /// Vrátí cursor, načtený ze souboru lns.cur.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Arrow_NS_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Arrow_NS, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_DJs\lns.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Arrow_NS_Direct
        {
            get
            {
                if (_Arrow_NS != null) return _Arrow_NS;
                _Arrow_NS = Arrow_NS;
                return _Arrow_NS;
            }
        }
        /// <summary>
        /// Vrátí cursor, načtený ze souboru lns.cur.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Arrow_NS_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho objektu Cursor (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat cursor často a rychle, je možné využít property Arrow_NS_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_DJs\lns.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Arrow_NS
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1024);
                sb.Append("AAACAAEAICAAAAgADwDoAgAAFgAAACgAAAAgAAAAQAAAAAEABAAAAAAAgAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDA");
                sb.Append("wAAAAP8AAP8AAAD//wD/AAAA/wD/AP//AAD///8AAAAAAA/wAAAAAAAAAAAAAAAAAADwDwAAAAAAAAAAAAAAAAAPAADwAAAAAAAAAAAAAAAA8AAADwAAAAAAAAAAAAAA");
                sb.Append("DwAP8ADwAAAAAAAAAAAAAPAA//8ADwAAAAAAAAAAAA8AD///8ADwAAAAAAAAAADwAP////8ADwAAAAAAAAAPAA//////8ADwAAAAAAAA8AAAAP//AAAADwAAAAAAAPAA");
                sb.Append("AAD//wAAAA8AAAAAAAD///8A//8A////AAAAAAAAAAAPAP//APAAAAAAAAAAAAAADwD//wDwAAAAAAAAAAAAAA8A//8A8AAAAAAAAAAAAAAPAP//APAAAAAAAAAAAAAA");
                sb.Append("DwD//wDwAAAAAAAAAAAAAA8A//8A8AAAAAAAAAAAAAAPAP//APAAAAAAAAAAAAAADwD//wDwAAAAAAAAAAD///8A//8A////AAAAAAAA8AAAAP//AAAADwAAAAAAAPAA");
                sb.Append("AAD//wAAAA8AAAAAAAAPAA//////8ADwAAAAAAAAAPAA/////wAPAAAAAAAAAAAPAA////AA8AAAAAAAAAAAAPAA//8ADwAAAAAAAAAAAAAPAA/wAPAAAAAAAAAAAAAA");
                sb.Append("APAAAA8AAAAAAAAAAAAAAAAPAADwAAAAAAAAAAAAAAAAAPAPAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAD/n////w////4H///8A///+AH///AA///gAH//wAA//4AA");
                sb.Append("H/8AAA//AAAP/wAAD//4Af//+AH///gB///4Af//+AH///gB///4Af//+AH//wAAD/8AAA//AAAP/4AAH//AAD//4AB///AA///4Af///AP///4H////D////5///w==");
                return ConvertStringToCursor(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje cursor v paměti.
        /// Následující použití property Arrow_NS_Direct si vytvoří novou, korektní - podle originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost cursoru v paměti nejistá.
        /// </summary>
        public static void Arrow_NS_Reset()
        {
            _Arrow_NS = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Arrow_NS_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Windows.Forms.Cursor _Arrow_NS = null;
        #endregion
        #region Cursor Arrow_WE
        /// <summary>
        /// Vrátí cursor, načtený ze souboru lwe.cur.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Arrow_WE_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Arrow_WE, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_DJs\lwe.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Arrow_WE_Direct
        {
            get
            {
                if (_Arrow_WE != null) return _Arrow_WE;
                _Arrow_WE = Arrow_WE;
                return _Arrow_WE;
            }
        }
        /// <summary>
        /// Vrátí cursor, načtený ze souboru lwe.cur.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Arrow_WE_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho objektu Cursor (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat cursor často a rychle, je možné využít property Arrow_WE_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\Cs2008\_LcsPicLibrary\_DJs\lwe.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Arrow_WE
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1024);
                sb.Append("AAACAAEAICAAABAACQDoAgAAFgAAACgAAAAgAAAAQAAAAAEABAAAAAAAgAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDA");
                sb.Append("wAAAAP8AAP8AAAD//wD/AAAA/wD/AP//AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
                sb.Append("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
                sb.Append("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//AAAAAP/wAAAAAAAAAADwDwAAAADwDwAAAAAAAAAPAA8AAAAA8ADwAAAAAAAA8AAPAAAAAPAADwAAAAAA");
                sb.Append("DwAADwAAAADwAADwAAAAAPAA8A//////8A8ADwAAAA8AD/AAAAAAAAAP8ADwAADwAP/wAAAAAAAAD/8ADwAPAA//////////////8ADw8AD///////////////8AD/AA");
                sb.Append("////////////////AA8PAA//////////////8ADwAPAA//AAAAAAAAAP/wAPAAAPAA/wAAAAAAAAD/AA8AAAAPAA8A//////8A8ADwAAAAAPAAAPAAAAAPAAAPAAAAAA");
                sb.Append("APAADwAAAADwAA8AAAAAAAAPAA8AAAAA8ADwAAAAAAAAAPAPAAAAAPAPAAAAAAAAAAAP/wAAAAD/8AAAAAD/////////////////////////////////////////////");
                sb.Append("////////////////////j/H//w/w//4P8H/8D/A/+A/wH/AAAA/gAAAHwAAAA4AAAAEAAAAAAAAAAIAAAAHAAAAD4AAAB/AAAA/4D/Af/A/wP/4P8H//D/D//4/x/w==");
                return ConvertStringToCursor(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje cursor v paměti.
        /// Následující použití property Arrow_WE_Direct si vytvoří novou, korektní - podle originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost cursoru v paměti nejistá.
        /// </summary>
        public static void Arrow_WE_Reset()
        {
            _Arrow_WE = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Arrow_WE_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Windows.Forms.Cursor _Arrow_WE = null;
        #endregion
        #region Obrázek Pin_red24
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru pin_red24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Pin_red24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Pin_red24, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\Images\pin_red24.png
        /// </remarks>
        public static System.Drawing.Image Pin_red24_Direct
        {
            get
            {
                if (_Pin_red24 != null) return _Pin_red24;
                _Pin_red24 = Pin_red24;
                return _Pin_red24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru pin_red24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Pin_red24_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Pin_red24_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\CsProj\WinApsClientDaj\WinApsClientDaj\Images\pin_red24.png
        /// </remarks>
        public static System.Drawing.Image Pin_red24
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(1300);
                sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAK7wAACu8BfXaKSAAAAAd0SU1FB9MFFQsxO4xa7YsAAAAYdEVY");
                sb.Append("dFNvZnR3YXJlAFBhaW50Lk5FVCB2My4zNTDus58AAAM6SURBVEhLrZRrSFNhHIed6QjKzNCmc3M63VZsOXNrW3OZkqTOaSu03NJsFXlJIrOyC4WXFIqlRkFERBJYQUh0");
                sb.Append("80uRJbNmZYrO1NLNAsVL94Syi7/es/wUgZ6xAw/nfPi/z/O+HM5heNC4Jk0K5qcpb5XXHE/ulAcmfk/+eh5Ybx2iofj/KBRqxqhBsbtzTcSYZbUQLXoNWrQyWGN4v+3r");
                sb.Append("IhveZypDXI58kEg9e7Tiyw9UIXixbzsGr17A0O1reHv9EvpOl+FRmhJtcfyRHp10qUuR14niwiYVBx3F2eg9eQD281UYrKuG4+IJvK45DNvRXDSnReN5LL97KCGMSSvi");
                sb.Append("WCVgtqpDRixpkegsSkdv+U4MVBfDceYg7LX78aoqH7YSA9p2JKBJ4Y/OGFE2rYBtJV/VvJKFlgQ2OrYq0VOcgv7STNgrt8BeYURfSRq6dqrxNDUUzbH+sCpDr9AKtMt4");
                sb.Append("ekssC61JLLTr2ejaxMHLzVz0Zv+Feu7cGIwX64JgTWThyYrgh7QCrZGcuCfxgWhfz0a3kYtX20Jhz+NjcFe4k4FcPvq28mDL5Dgjlmj2DVoBqyDApyUmaMJmIPLtoXhT");
                sb.Append("GI7hYiFGSkROhvYK4CggERMPHRuC0SRk7aEVoIbvixabuw0hcOTzMbxPiHfHluJzhRifCONHljgj1KkexwSNPQsL8KMduCFkz29Q8L85iGTs0BJ8qZTge40U305JnZHR");
                sb.Append("QyK0aTk/GoP9kmnLqQV5+fmrmu7dQ128El3rufhYKsbPs8sxWRuFt4UCWNSB/bdYC+JcklOLioqKzt1tbERKaiqytcko4XEtN9kLzQ0BPmV3/OenPPD18HZZbjKZmGaz");
                sb.Append("ebygoAAZGRnQaDT9KpVqkcvCfxfm5OSklJeXQ6fTISkpaUImk0ndJqdEJFCflZUFvV4/JZfLDW6Vp6enM41G41etVgu1Wl3jVjklk0gk3kTsiIqK6mcwGNQHJCLQ+1vO");
                sb.Append("YldrycxxwhaChkC9g0B3huYQmY4QT5ATxAT+dGQeuXvOYpMzjiwgEzLCMoKAwCH4E9wWoHZASSMIXMJiAhV16/vwIkL2tNyX3OcSGDOeneYAtWNKTP0aZi3/A+dIadYg");
                sb.Append("CKQtAAAAAElFTkSuQmCC");
                return ConvertStringToImage(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Pin_red24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Pin_red24_Reset()
        {
            _Pin_red24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Pin_red24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Pin_red24 = null;
        #endregion
        #region Cursor Magnify
        /// <summary>
        /// Vrátí cursor, načtený ze souboru magnify.cur.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Magnify_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Magnify, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\C#\WinApsClientDaj\WinApsClientDaj\pic\magnify.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Magnify_Direct
        {
            get
            {
                if (_Magnify != null) return _Magnify;
                _Magnify = Magnify;
                return _Magnify;
            }
        }
        /// <summary>
        /// Vrátí cursor, načtený ze souboru magnify.cur.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Magnify_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho objektu Cursor (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat cursor často a rychle, je možné využít property Magnify_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\C#\WinApsClientDaj\WinApsClientDaj\pic\magnify.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Magnify
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(692);
                sb.Append("AAACAAIAICAAAAkACAAwAQAAJgAAABAQAAAHAAcAsAAAAFYBAAAoAAAAIAAAAEAAAAABAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///wAAAAAAAAAAAAAA");
                sb.Append("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH4AAAHDgAADAMAAAgBAAAYAYAAEACAABAAgAAYAYAACAEAAAwD");
                sb.Append("AAAHDgAAAfgAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////8f///+H////D//+Bh//+AA///AA");
                sb.Append("f//g8H//4/x//8P8P//H/j//x/4//8P8P//j/H//4PB///AA///4Af///gf/////////////KAAAABAAAAAgAAAAAQABAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
                sb.Append("AAD///8AAAAAAAAAAAAAAAAAB4AAABhgAAAgEAAAIBAAAEAIAABACAAAQAgAAEAIAAAgEAAAIBAAABhgAAAHgAAAAAAAAP/8AAD/+AAA+HEAAOADAADABwAAh4cAAI/H");
                sb.Append("AAAf4wAAH+MAAB/jAAAf4wAAj8cAAIeHAADADwAA4B8AAPh/AAA=");
                return ConvertStringToCursor(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje cursor v paměti.
        /// Následující použití property Magnify_Direct si vytvoří novou, korektní - podle originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost cursoru v paměti nejistá.
        /// </summary>
        public static void Magnify_Reset()
        {
            _Magnify = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Magnify_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Windows.Forms.Cursor _Magnify = null;
        #endregion
		#region Image TriangleDown
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_d.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu TriangleDown_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property TriangleDown, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleDown_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d.png
		/// </remarks>
		public static System.Drawing.Image TriangleDown_Cached
		{
			get
			{
				if (_TriangleDown == null) _TriangleDown = TriangleDown;
				return _TriangleDown;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_d.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image TriangleDown_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDown_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDown_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d.png
		/// </remarks>
		public static System.Drawing.Image TriangleDown { get { return _ImageCreateFrom(_TriangleDown_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru trian_d.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDown_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDown_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d.png
		/// </remarks>
		public static System.Drawing.Image TriangleDown_FromFile { get { return _ImageCreateFrom(_TriangleDown_string, "trian_d.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru TriangleDown
		/// </summary>
		/// <returns></returns>
		private static string _TriangleDown_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(412);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
			sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAABugAAAboB6KsBBgAAABl0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuODc7gF0AAAAwdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnMg");
			sb.Append("aHR0cDovL3d3dy5veHlnZW4taWNvbnMub3JnL7/G8xwAAAA9SURBVDhPY2AYBSSEgG8DCYrRlYI0+/0n0wCYZrIMQNZMsgHomkkyAJtmog3ApZkoA/BpJsoAMiNqaGsD");
			sb.Append("AMNAKtUeiCc1AAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property TriangleDown_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void TriangleDown_Reset()
		{
			_TriangleDown = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití TriangleDown_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _TriangleDown = null;
		#endregion
		#region Image TriangleRight
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_r.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu TriangleRight_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property TriangleRight, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleRight_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r.png
		/// </remarks>
		public static System.Drawing.Image TriangleRight_Cached
		{
			get
			{
				if (_TriangleRight == null) _TriangleRight = TriangleRight;
				return _TriangleRight;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_r.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image TriangleRight_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRight_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRight_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r.png
		/// </remarks>
		public static System.Drawing.Image TriangleRight { get { return _ImageCreateFrom(_TriangleRight_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru trian_r.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRight_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRight_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r.png
		/// </remarks>
		public static System.Drawing.Image TriangleRight_FromFile { get { return _ImageCreateFrom(_TriangleRight_string, "trian_r.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru TriangleRight
		/// </summary>
		/// <returns></returns>
		private static string _TriangleRight_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(404);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
			sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAABugAAAboB6KsBBgAAABl0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuODc7gF0AAAAwdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnMg");
			sb.Append("aHR0cDovL3d3dy5veHlnZW4taWNvbnMub3JnL7/G8xwAAAA1SURBVDhPY2AYzsDvP4W+AxlAkSEgzb4NFBgCs51sQ5CdT5YhVHEBWTbDIo8qsUBhShgh2gGcNRjSJn9H");
			sb.Append("swAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property TriangleRight_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void TriangleRight_Reset()
		{
			_TriangleRight = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití TriangleRight_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _TriangleRight = null;
		#endregion
        #region Image TriangleDownHot
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_d_h.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu TriangleDownHot_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property TriangleDownHot, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleDownHot_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleDownHot_Cached
        {
            get
            {
                if (_TriangleDownHot == null) _TriangleDownHot = TriangleDownHot;
                return _TriangleDownHot;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_d_h.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image TriangleDownHot_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDownHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDownHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleDownHot { get { return _ImageCreateFrom(_TriangleDownHot_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru trian_d_h.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDownHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDownHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleDownHot_FromFile { get { return _ImageCreateFrom(_TriangleDownHot_string, "trian_d_h.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru TriangleDownHot
        /// </summary>
        /// <returns></returns>
        private static string _TriangleDownHot_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(648);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA");
            sb.Append("CXBIWXMAAAG5AAABuQFFEiBrAAAAMHRFWHRTb3VyY2UAT3h5Z2VuIEljb25zIGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy+/xvMcAAAAGXRFWHRTb2Z0d2FyZQBQ");
            sb.Append("YWludC5ORVQgdjMuNS44NzuAXQAAAPlJREFUOE9jYKAX2PdIjxGIhYFYCohlgFgAiJmIth+omBeIzYHYCYgt9z3WkznwVI+FKANANgGxJhCXAHHZ/sd60UDN6qQYIGzm");
            sb.Append("4LIZaOtuoOZ1QI0VeA2A+hfkZzB2C3Y8w8Dg93/vY93fQI2niTWAE6iZMyDe7j5IMwgDNYIw8QbomrqugGkm1QBFGw/nPciaiTIAGtrCtp5O+9A14zUAGligeNYEhTY2");
            sb.Append("zYQMAKUwc2s35124NBMyQA5oQAgQzwDG8x1oaMNCHZ3GjAWgRnsgrgFq3gXU/IoAxmpABDCVtQE1riQCz8FISEDN9kBBfyKxD1CdIywpAwAkKmEIgjd/ugAAAABJRU5E");
            sb.Append("rkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property TriangleDownHot_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void TriangleDownHot_Reset()
        {
            _TriangleDownHot = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití TriangleDownHot_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _TriangleDownHot = null;
        #endregion
        #region Image TriangleRightHot
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_r_h.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu TriangleRightHot_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property TriangleRightHot, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleRightHot_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleRightHot_Cached
        {
            get
            {
                if (_TriangleRightHot == null) _TriangleRightHot = TriangleRightHot;
                return _TriangleRightHot;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_r_h.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image TriangleRightHot_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRightHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRightHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleRightHot { get { return _ImageCreateFrom(_TriangleRightHot_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru trian_r_h.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRightHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRightHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleRightHot_FromFile { get { return _ImageCreateFrom(_TriangleRightHot_string, "trian_r_h.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru TriangleRightHot
        /// </summary>
        /// <returns></returns>
        private static string _TriangleRightHot_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(620);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA");
            sb.Append("CXBIWXMAAAG5AAABuQFFEiBrAAAAMHRFWHRTb3VyY2UAT3h5Z2VuIEljb25zIGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy+/xvMcAAAAGXRFWHRTb2Z0d2FyZQBQ");
            sb.Append("YWludC5ORVQgdjMuNS44NzuAXQAAAOVJREFUOE9jYKAl2P9cX4Es8/c/0V134KnefxAGsreSbMiBJ7pfGBj8wAZADNErIcmQ/U/13oIMINuQA0/0XoM0xxfZohryTLeQ");
            sb.Append("KJcceKr7EmZ7XCGaIY90awgaAvT3c7jzH+mtBhryD9k7Bx7q2uI15MBT/ccwDe6hjmfB7GfQAH2s+3f/Ux0NvAbsf6wDjgX0MACGDdAgnVkEvbDvid43eCxAbQZH52Pd");
            sb.Append("AoKaQQqA8f4Txc9Pdd/vf6TnQZRmkCJQQoIlogOPdb/vf6JvQLRmiAt0aoFRuRdoyLv9z3UTSNJMd8UAKMC3yb6T6eAAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property TriangleRightHot_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void TriangleRightHot_Reset()
        {
            _TriangleRightHot = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití TriangleRightHot_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _TriangleRightHot = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI olds
        /// <summary>
        /// Vrátí Image z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Image vytvořený z dat</returns>
        public static System.Drawing.Image ConvertStringToImage(string data)
        {
            System.Drawing.Image image;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                image = System.Drawing.Image.FromStream(ms);
            }
            return image;
        }
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
		#region SPOLEČNÉ METODY PRO KONVERZI new
		/// <summary>
		/// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
		/// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
		/// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
		/// Pokud soubor neexistuje, nejprve se vytvoří.
		/// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
		/// Obsah obrázku definuje metoda getDataMethod.
		/// </summary>
		/// <param name="getDataMethod"></param>
		/// <param name="cacheFileName"></param>
		/// <returns></returns>
		private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
		{
			System.Drawing.Image image;
			if (cacheFileName == null)
			{
				using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
				{
					image = System.Drawing.Image.FromStream(ms);
				}
				return image;
			}
			string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
			if (!System.IO.File.Exists(fileName))
				System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
			if (System.IO.File.Exists(fileName))
				return Image.FromFile(fileName);
			return null;
		}
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                    __ImageCacheDir = Noris.Tools.TraceVisualiser.Support.Steward.GetUserAppDataPath(@"IconCache\PicsCIc");
                return __ImageCacheDir;
            }
        }
        private static string __ImageCacheDir;
		/// <summary>
		/// Předpis pro metody, které generují obsah souboru s daty
		/// </summary>
		/// <returns></returns>
		private delegate string _GetStringDelegate();
		///// <summary>
		///// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
		///// </summary>
		///// <param name="data">Vstupní data v kódování Base64</param>
		///// <returns>Icon vytvořená z dat</returns>
		//public static System.Drawing.Icon ConvertStringToIcon(string data)
		//{
		//    System.Drawing.Icon icon;
		//    using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
		//    {
		//        icon = new System.Drawing.Icon(ms);
		//    }
		//    return icon;
		//}
		///// <summary>
		///// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
		///// </summary>
		///// <param name="data">Vstupní data v kódování Base64</param>
		///// <returns>Cursor vytvořený z dat</returns>
		//public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
		//{
		//    System.Windows.Forms.Cursor cursor;
		//    using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
		//    {
		//        cursor = new System.Windows.Forms.Cursor(ms);
		//    }
		//    return cursor;
		//}
		#endregion
    }
}
